/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package JPAControllers;

import JPAControllers.exceptions.IllegalOrphanException;
import JPAControllers.exceptions.NonexistentEntityException;
import Persistencia.Sesion;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import Persistencia.Informe;
import Persistencia.Paciente;
import Persistencia.Fisioterapeuta;
import Persistencia.Tratamiento;
import java.util.ArrayList;
import java.util.List;
import Persistencia.Comentariovideo;

/**
 *
 * @author veinti
 */
public class SesionJpaController {

    public SesionJpaController() {
        emf = Persistence.createEntityManagerFactory("fisiosoftJDVPU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Sesion sesion) {
        if (sesion.getTratamientoList() == null) {
            sesion.setTratamientoList(new ArrayList<Tratamiento>());
        }
        if (sesion.getComentariovideoList() == null) {
            sesion.setComentariovideoList(new ArrayList<Comentariovideo>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Informe informe = sesion.getInforme();
            if (informe != null) {
                informe = em.getReference(informe.getClass(), informe.getIdInforme());
                sesion.setInforme(informe);
            }
            Paciente paciente = sesion.getPaciente();
            if (paciente != null) {
                paciente = em.getReference(paciente.getClass(), paciente.getIdPaciente());
                sesion.setPaciente(paciente);
            }
            Fisioterapeuta fisioterapeuta = sesion.getFisioterapeuta();
            if (fisioterapeuta != null) {
                fisioterapeuta = em.getReference(fisioterapeuta.getClass(), fisioterapeuta.getIdFisioterapeuta());
                sesion.setFisioterapeuta(fisioterapeuta);
            }
            List<Tratamiento> attachedTratamientoList = new ArrayList<Tratamiento>();
            for (Tratamiento tratamientoListTratamientoToAttach : sesion.getTratamientoList()) {
                tratamientoListTratamientoToAttach = em.getReference(tratamientoListTratamientoToAttach.getClass(), tratamientoListTratamientoToAttach.getIdTratamiento());
                attachedTratamientoList.add(tratamientoListTratamientoToAttach);
            }
            sesion.setTratamientoList(attachedTratamientoList);
            List<Comentariovideo> attachedComentariovideoList = new ArrayList<Comentariovideo>();
            for (Comentariovideo comentariovideoListComentariovideoToAttach : sesion.getComentariovideoList()) {
                comentariovideoListComentariovideoToAttach = em.getReference(comentariovideoListComentariovideoToAttach.getClass(), comentariovideoListComentariovideoToAttach.getIdComentariovideo());
                attachedComentariovideoList.add(comentariovideoListComentariovideoToAttach);
            }
            sesion.setComentariovideoList(attachedComentariovideoList);
            em.persist(sesion);
            if (informe != null) {
                Sesion oldSesionOfInforme = informe.getSesion();
                if (oldSesionOfInforme != null) {
                    oldSesionOfInforme.setInforme(null);
                    oldSesionOfInforme = em.merge(oldSesionOfInforme);
                }
                informe.setSesion(sesion);
                informe = em.merge(informe);
            }
            if (paciente != null) {
                paciente.getSesionList().add(sesion);
                paciente = em.merge(paciente);
            }
            if (fisioterapeuta != null) {
                fisioterapeuta.getSesionList().add(sesion);
                fisioterapeuta = em.merge(fisioterapeuta);
            }
            for (Tratamiento tratamientoListTratamiento : sesion.getTratamientoList()) {
                Sesion oldSesionOfTratamientoListTratamiento = tratamientoListTratamiento.getSesion();
                tratamientoListTratamiento.setSesion(sesion);
                tratamientoListTratamiento = em.merge(tratamientoListTratamiento);
                if (oldSesionOfTratamientoListTratamiento != null) {
                    oldSesionOfTratamientoListTratamiento.getTratamientoList().remove(tratamientoListTratamiento);
                    oldSesionOfTratamientoListTratamiento = em.merge(oldSesionOfTratamientoListTratamiento);
                }
            }
            for (Comentariovideo comentariovideoListComentariovideo : sesion.getComentariovideoList()) {
                Sesion oldSesionOfComentariovideoListComentariovideo = comentariovideoListComentariovideo.getSesion();
                comentariovideoListComentariovideo.setSesion(sesion);
                comentariovideoListComentariovideo = em.merge(comentariovideoListComentariovideo);
                if (oldSesionOfComentariovideoListComentariovideo != null) {
                    oldSesionOfComentariovideoListComentariovideo.getComentariovideoList().remove(comentariovideoListComentariovideo);
                    oldSesionOfComentariovideoListComentariovideo = em.merge(oldSesionOfComentariovideoListComentariovideo);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Sesion sesion) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Sesion persistentSesion = em.find(Sesion.class, sesion.getIdSesion());
            Informe informeOld = persistentSesion.getInforme();
            Informe informeNew = sesion.getInforme();
            Paciente pacienteOld = persistentSesion.getPaciente();
            Paciente pacienteNew = sesion.getPaciente();
            Fisioterapeuta fisioterapeutaOld = persistentSesion.getFisioterapeuta();
            Fisioterapeuta fisioterapeutaNew = sesion.getFisioterapeuta();
            List<Tratamiento> tratamientoListOld = persistentSesion.getTratamientoList();
            List<Tratamiento> tratamientoListNew = sesion.getTratamientoList();
            List<Comentariovideo> comentariovideoListOld = persistentSesion.getComentariovideoList();
            List<Comentariovideo> comentariovideoListNew = sesion.getComentariovideoList();
            List<String> illegalOrphanMessages = null;
            if (informeOld != null && !informeOld.equals(informeNew)) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("You must retain Informe " + informeOld + " since its sesion field is not nullable.");
            }
            for (Comentariovideo comentariovideoListOldComentariovideo : comentariovideoListOld) {
                if (!comentariovideoListNew.contains(comentariovideoListOldComentariovideo)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Comentariovideo " + comentariovideoListOldComentariovideo + " since its sesion field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (informeNew != null) {
                informeNew = em.getReference(informeNew.getClass(), informeNew.getIdInforme());
                sesion.setInforme(informeNew);
            }
            if (pacienteNew != null) {
                pacienteNew = em.getReference(pacienteNew.getClass(), pacienteNew.getIdPaciente());
                sesion.setPaciente(pacienteNew);
            }
            if (fisioterapeutaNew != null) {
                fisioterapeutaNew = em.getReference(fisioterapeutaNew.getClass(), fisioterapeutaNew.getIdFisioterapeuta());
                sesion.setFisioterapeuta(fisioterapeutaNew);
            }
            List<Tratamiento> attachedTratamientoListNew = new ArrayList<Tratamiento>();
            for (Tratamiento tratamientoListNewTratamientoToAttach : tratamientoListNew) {
                tratamientoListNewTratamientoToAttach = em.getReference(tratamientoListNewTratamientoToAttach.getClass(), tratamientoListNewTratamientoToAttach.getIdTratamiento());
                attachedTratamientoListNew.add(tratamientoListNewTratamientoToAttach);
            }
            tratamientoListNew = attachedTratamientoListNew;
            sesion.setTratamientoList(tratamientoListNew);
            List<Comentariovideo> attachedComentariovideoListNew = new ArrayList<Comentariovideo>();
            for (Comentariovideo comentariovideoListNewComentariovideoToAttach : comentariovideoListNew) {
                comentariovideoListNewComentariovideoToAttach = em.getReference(comentariovideoListNewComentariovideoToAttach.getClass(), comentariovideoListNewComentariovideoToAttach.getIdComentariovideo());
                attachedComentariovideoListNew.add(comentariovideoListNewComentariovideoToAttach);
            }
            comentariovideoListNew = attachedComentariovideoListNew;
            sesion.setComentariovideoList(comentariovideoListNew);
            sesion = em.merge(sesion);
            if (informeNew != null && !informeNew.equals(informeOld)) {
                Sesion oldSesionOfInforme = informeNew.getSesion();
                if (oldSesionOfInforme != null) {
                    oldSesionOfInforme.setInforme(null);
                    oldSesionOfInforme = em.merge(oldSesionOfInforme);
                }
                informeNew.setSesion(sesion);
                informeNew = em.merge(informeNew);
            }
            if (pacienteOld != null && !pacienteOld.equals(pacienteNew)) {
                pacienteOld.getSesionList().remove(sesion);
                pacienteOld = em.merge(pacienteOld);
            }
            if (pacienteNew != null && !pacienteNew.equals(pacienteOld)) {
                pacienteNew.getSesionList().add(sesion);
                pacienteNew = em.merge(pacienteNew);
            }
            if (fisioterapeutaOld != null && !fisioterapeutaOld.equals(fisioterapeutaNew)) {
                fisioterapeutaOld.getSesionList().remove(sesion);
                fisioterapeutaOld = em.merge(fisioterapeutaOld);
            }
            if (fisioterapeutaNew != null && !fisioterapeutaNew.equals(fisioterapeutaOld)) {
                fisioterapeutaNew.getSesionList().add(sesion);
                fisioterapeutaNew = em.merge(fisioterapeutaNew);
            }
            for (Tratamiento tratamientoListOldTratamiento : tratamientoListOld) {
                if (!tratamientoListNew.contains(tratamientoListOldTratamiento)) {
                    tratamientoListOldTratamiento.setSesion(null);
                    tratamientoListOldTratamiento = em.merge(tratamientoListOldTratamiento);
                }
            }
            for (Tratamiento tratamientoListNewTratamiento : tratamientoListNew) {
                if (!tratamientoListOld.contains(tratamientoListNewTratamiento)) {
                    Sesion oldSesionOfTratamientoListNewTratamiento = tratamientoListNewTratamiento.getSesion();
                    tratamientoListNewTratamiento.setSesion(sesion);
                    tratamientoListNewTratamiento = em.merge(tratamientoListNewTratamiento);
                    if (oldSesionOfTratamientoListNewTratamiento != null && !oldSesionOfTratamientoListNewTratamiento.equals(sesion)) {
                        oldSesionOfTratamientoListNewTratamiento.getTratamientoList().remove(tratamientoListNewTratamiento);
                        oldSesionOfTratamientoListNewTratamiento = em.merge(oldSesionOfTratamientoListNewTratamiento);
                    }
                }
            }
            for (Comentariovideo comentariovideoListNewComentariovideo : comentariovideoListNew) {
                if (!comentariovideoListOld.contains(comentariovideoListNewComentariovideo)) {
                    Sesion oldSesionOfComentariovideoListNewComentariovideo = comentariovideoListNewComentariovideo.getSesion();
                    comentariovideoListNewComentariovideo.setSesion(sesion);
                    comentariovideoListNewComentariovideo = em.merge(comentariovideoListNewComentariovideo);
                    if (oldSesionOfComentariovideoListNewComentariovideo != null && !oldSesionOfComentariovideoListNewComentariovideo.equals(sesion)) {
                        oldSesionOfComentariovideoListNewComentariovideo.getComentariovideoList().remove(comentariovideoListNewComentariovideo);
                        oldSesionOfComentariovideoListNewComentariovideo = em.merge(oldSesionOfComentariovideoListNewComentariovideo);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = sesion.getIdSesion();
                if (findSesion(id) == null) {
                    throw new NonexistentEntityException("The sesion with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Sesion sesion;
            try {
                sesion = em.getReference(Sesion.class, id);
                sesion.getIdSesion();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The sesion with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Informe informeOrphanCheck = sesion.getInforme();
            if (informeOrphanCheck != null) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Sesion (" + sesion + ") cannot be destroyed since the Informe " + informeOrphanCheck + " in its informe field has a non-nullable sesion field.");
            }
            List<Comentariovideo> comentariovideoListOrphanCheck = sesion.getComentariovideoList();
            for (Comentariovideo comentariovideoListOrphanCheckComentariovideo : comentariovideoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Sesion (" + sesion + ") cannot be destroyed since the Comentariovideo " + comentariovideoListOrphanCheckComentariovideo + " in its comentariovideoList field has a non-nullable sesion field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Paciente paciente = sesion.getPaciente();
            if (paciente != null) {
                paciente.getSesionList().remove(sesion);
                paciente = em.merge(paciente);
            }
            Fisioterapeuta fisioterapeuta = sesion.getFisioterapeuta();
            if (fisioterapeuta != null) {
                fisioterapeuta.getSesionList().remove(sesion);
                fisioterapeuta = em.merge(fisioterapeuta);
            }
            List<Tratamiento> tratamientoList = sesion.getTratamientoList();
            for (Tratamiento tratamientoListTratamiento : tratamientoList) {
                tratamientoListTratamiento.setSesion(null);
                tratamientoListTratamiento = em.merge(tratamientoListTratamiento);
            }
            em.remove(sesion);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Sesion> findSesionEntities() {
        return findSesionEntities(true, -1, -1);
    }

    public List<Sesion> findSesionEntities(int maxResults, int firstResult) {
        return findSesionEntities(false, maxResults, firstResult);
    }

    private List<Sesion> findSesionEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Sesion.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Sesion findSesion(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Sesion.class, id);
        } finally {
            em.close();
        }
    }

    public int getSesionCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Sesion> rt = cq.from(Sesion.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
